const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');

const Tag = sequelize.define('Tag', {
  id: {
    type: DataTypes.BIGINT,
    primaryKey: true,
    autoIncrement: true
  },
  name: {
    type: DataTypes.STRING(50),
    allowNull: false,
    unique: true
  },
  use_count: {
    type: DataTypes.INTEGER,
    defaultValue: 0
  },
  status: {
    type: DataTypes.TINYINT,
    defaultValue: 1
  },
  createdAt: {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW
  },
  updatedAt: {
    type: DataTypes.DATE,
    defaultValue: DataTypes.NOW,
    onUpdate: DataTypes.NOW
  },
  deletedAt: {
    type: DataTypes.DATE,
    allowNull: true
  }
}, {
  tableName: 'tag',
  timestamps: true,
  paranoid: true
});

// 获取所有标签
Tag.getAllTags = async function() {
  try {
    return await this.findAll({
      where: {
        status: 1
      },
      attributes: ['id', 'name', 'use_count'],
      order: [['use_count', 'DESC']]
    });
  } catch (error) {
    console.error('获取所有标签失败:', error);
    throw error;
  }
};

// 根据ID获取标签
Tag.getTagById = async function(id) {
  try {
    return await this.findByPk(id, {
      attributes: ['id', 'name', 'use_count']
    });
  } catch (error) {
    console.error('根据ID获取标签失败:', error);
    throw error;
  }
};

// 创建新标签
Tag.createTag = async function(tagData) {
  try {
    return await this.create(tagData);
  } catch (error) {
    console.error('创建标签失败:', error);
    throw error;
  }
};

// 更新标签使用次数
Tag.updateUseCount = async function(id) {
  try {
    return await this.increment('use_count', {
      where: { id }
    });
  } catch (error) {
    console.error('更新标签使用次数失败:', error);
    throw error;
  }
};

module.exports = Tag;
const Tag = sequelize.define('Tag', {
  // 主键ID
  id: {
    type: DataTypes.BIGINT,
    primaryKey: true,
    autoIncrement: true,
    allowNull: false
  },
  
  // 标签名称
  name: {
    type: DataTypes.STRING(50),
    allowNull: false,
    unique: true,
    validate: {
      notEmpty: {
        msg: '标签名称不能为空'
      },
      len: {
        args: [1, 50],
        msg: '标签名称长度必须在1-50个字符之间'
      }
    }
  },
  
  // 使用次数
  use_count: {
    type: DataTypes.INTEGER,
    allowNull: true,
    defaultValue: 0,
    validate: {
      min: 0
    }
  },
  
  // 状态
  status: {
    type: DataTypes.TINYINT,
    allowNull: false,
    defaultValue: 1,
    validate: {
      isIn: {
        args: [[0, 1]],
        msg: '状态值无效'
      }
    }
  },
  
  // 创建时间
  createdAt: {
    type: DataTypes.DATE,
    allowNull: false,
    defaultValue: DataTypes.NOW
  },
  
  // 更新时间
  updatedAt: {
    type: DataTypes.DATE,
    allowNull: false,
    defaultValue: DataTypes.NOW
  },
  
  // 删除时间（软删除）
  deletedAt: {
    type: DataTypes.DATE,
    allowNull: true
  }
}, {
  // 表配置
  tableName: 'tag',
  timestamps: true,
  paranoid: true, // 启用软删除
  underscored: true, // 使用下划线命名
  charset: 'utf8mb4',
  collate: 'utf8mb4_unicode_ci',
  indexes: [
    {
      unique: true,
      fields: ['name']
    },
    {
      fields: ['use_count']
    },
    {
      fields: ['status']
    }
  ]
});

// 类方法：获取所有标签
Tag.getAllTags = async function() {
  return await this.findAll({
    where: {
      status: 1
    },
    order: [['use_count', 'DESC']],
    attributes: ['id', 'name', 'use_count']
  });
};

// 类方法：根据ID获取标签
Tag.getTagById = async function(id) {
  return await this.findByPk(id, {
    attributes: ['id', 'name', 'use_count', 'status', 'createdAt']
  });
};

// 类方法：创建标签
Tag.createTag = async function(name) {
  return await this.create({
    name,
    use_count: 0,
    status: 1
  });
};

// 实例方法：增加使用次数
Tag.prototype.incrementUseCount = async function() {
  this.use_count += 1;
  await this.save();
};

// 实例方法：减少使用次数
Tag.prototype.decrementUseCount = async function() {
  if (this.use_count > 0) {
    this.use_count -= 1;
    await this.save();
  }
};

module.exports = Tag;

// 导出到全局，方便其他模块使用
global.Tag = Tag;